home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 June: Reference Library / Dev.CD Jun 96 RL / Dev.CD Jun 96 RL.toast / Technical Documentation / develop / develop Issue 24 / develop Issue 24 code / Scriptable Database 1.0a15 / Foundation / AbstractSearchSpec.cp < prev    next >
Encoding:
Text File  |  1996-02-19  |  10.4 KB  |  298 lines  |  [TEXT/CWIE]
  1. /*
  2.     File:        AbstractSearchSpec.c
  3.  
  4.     Contains:    xxx put contents here xxx
  5.  
  6.     Written by:    Andy Nicholas, Greg Anderson, Tom Conrad, Chris Bingham, Georgiann Puckett, John Thompson-Rohrlich
  7.  
  8.     Copyright:    © 1994-1995 by Apple Computer, Inc., all rights reserved.
  9.  
  10.         <19>     9/18/95    ga        
  11.  
  12. */
  13.  
  14.  
  15. #ifdef MWTRACEBACKTABLES
  16. #pragma traceback on
  17. #endif
  18.  
  19. #include "AbstractSearchSpec.h"
  20.  
  21. #include "AbstractScriptableObject.h"
  22. #include "ScriptableObjectList.h"
  23.  
  24. //
  25. // GenericSearchEngine is needed because a
  26. // TGenericSearchEngine is created by default
  27. // in TAbstractSearchSpec::CreateSearchEngine
  28. //
  29. //#include "GenericSearchEngine.h"
  30.  
  31. #include <AEObjects.h>
  32.  
  33. #include "Exceptions.h"
  34.  
  35. //========================================================================================
  36. // CLASS TAbstractSearchSpec
  37. //========================================================================================
  38.  
  39. #ifndef clSearchSpec
  40. #define clSearchSpec 5689
  41. #endif
  42.  
  43. #pragma segment ObjectResident
  44. ImplementSmallClassData(TAbstractSearchSpec, clSearchSpec);
  45.  
  46. #pragma segment SearchSpec
  47.  
  48. //----------------------------------------------------------------------------------------
  49. // TAbstractSearchSpec::SpecificationOperator: 
  50. //
  51. // This function returns the operator performed by this specification
  52. //----------------------------------------------------------------------------------------
  53. DescType TAbstractSearchSpec::SpecificationOperator()
  54.     {
  55.     return typeNull;
  56.     } // TAbstractSearchSpec::SpecificationOperator 
  57.  
  58. //----------------------------------------------------------------------------------------
  59. // TAbstractSearchSpec::NumberOfSubterms
  60. //----------------------------------------------------------------------------------------
  61. long TAbstractSearchSpec::NumberOfSubterms()
  62.     {
  63.     return 0;
  64.     }
  65.     
  66. //----------------------------------------------------------------------------------------
  67. // TAbstractSearchSpec::SpecificationForTerm
  68. //----------------------------------------------------------------------------------------
  69. TAbstractSearchSpec* TAbstractSearchSpec::SpecificationForTerm(long /*term*/)
  70.     {
  71.     return nil;
  72.     }
  73.  
  74. //----------------------------------------------------------------------------------------
  75. // TAbstractSearchSpec::AccessBySearchSpec
  76. //----------------------------------------------------------------------------------------
  77. void TAbstractSearchSpec::AccessBySearchSpec(const TAETransaction& t, TAbstractCollector* collector, DescType desiredClass, TAbstractScriptableObject* objectToSearch)
  78.     {
  79.     objectToSearch->AccessBySearchSpec(t, collector, desiredClass, this);
  80.     } // TAbstractSearchSpec::AccessBySearchSpec
  81.  
  82. //----------------------------------------------------------------------------------------
  83. // TAbstractSearchSpec::BuildObjectSpecifier: 
  84. //----------------------------------------------------------------------------------------
  85. TDescriptor TAbstractSearchSpec::BuildObjectSpecifier(DescType desiredClass, TDescriptor rootOfSearch)
  86.     {
  87.     TDescriptor specifier;
  88.     TDescriptor whoseTest;
  89.     
  90.     whoseTest = this->BuildWhoseTest();
  91.     specifier.MakeObjectSpecifier(desiredClass, rootOfSearch, formTest, whoseTest, true);
  92.     
  93.     return specifier;
  94.     } // TAbstractSearchSpec::BuildObjectSpecifier 
  95.  
  96. //----------------------------------------------------------------------------------------
  97. // TAbstractSearchSpec::BuildWhoseTest: 
  98. //----------------------------------------------------------------------------------------
  99. TDescriptor TAbstractSearchSpec::BuildWhoseTest()
  100.     {
  101.     TDescriptor specifier;
  102.  
  103.     FailErr(errAEEventNotHandled);
  104.         
  105.     return specifier;
  106.     } // TAbstractSearchSpec::BuildWhoseTest 
  107.  
  108. //----------------------------------------------------------------------------------------
  109. // TAbstractSearchSpec::GetRightHandComparisonOperand
  110. //----------------------------------------------------------------------------------------
  111. TComparisonOperand* TAbstractSearchSpec::GetRightHandComparisonOperand()
  112.     {
  113.     return nil;
  114.     }
  115.     
  116. //----------------------------------------------------------------------------------------
  117. // TAbstractSearchSpec::GetLeftHandComparisonOperand
  118. //----------------------------------------------------------------------------------------
  119. TComparisonOperand* TAbstractSearchSpec::GetLeftHandComparisonOperand()
  120.     {
  121.     return nil;
  122.     }
  123.  
  124. //----------------------------------------------------------------------------------------
  125. // TAbstractSearchSpec::AddTermToSpecification
  126. //----------------------------------------------------------------------------------------
  127. TAbstractSearchSpec* TAbstractSearchSpec::AddTermToSpecification(TAbstractSearchSpec* newSpecification)
  128.     {
  129.     AListOf<TAbstractSearchSpec*>* specificationList = new AListOf<TAbstractSearchSpec*>;
  130.     
  131.     specificationList->Add(this);
  132.     specificationList->Add(newSpecification);
  133.     
  134.     return new TLogicalSearchSpec(kAEAND, specificationList);
  135.     } // TAbstractSearchSpec::AddTermToSpecification
  136.  
  137. //----------------------------------------------------------------------------------------
  138. // TAbstractSearchSpec::CreateSearchEngine: 
  139. //----------------------------------------------------------------------------------------
  140. TAbstractSearchEngine* TAbstractSearchSpec::CreateSearchEngine()
  141.     {
  142.     FailErr(errAEEventNotHandled);
  143.     
  144.     return nil;
  145.     } // TAbstractSearchSpec::CreateSearchEngine 
  146.  
  147.  
  148. //----------------------------------------------------------------------------------------
  149. // TAbstractSearchSpec::CreateSearchEngines: 
  150. //----------------------------------------------------------------------------------------
  151. void TAbstractSearchSpec::CreateSearchEngines(TSearchEngineList* /*searchEngines*/, TAbstractScriptableObject* /*owner*/)
  152.     {
  153.     } // TAbstractSearchSpec::CreateSearchEngines
  154.     
  155. //----------------------------------------------------------------------------------------
  156. // TViewerSpec::ShouldSearch: 
  157. //----------------------------------------------------------------------------------------
  158. #pragma segment ViewerIdle
  159. Boolean    TAbstractSearchSpec::ShouldSearch (TAbstractScriptableObject* /*disk*/)
  160.     {
  161.     return true;
  162.     } // TAbstractSearchSpec::ShouldSearch 
  163.  
  164.  
  165. //========================================================================================
  166. // CLASS TLogicalSearchSpec
  167. //========================================================================================
  168.  
  169. #pragma segment ObjectResident
  170. ImplementSmallClassData(TLogicalSearchSpec, clLogicalSearchSpec);
  171.  
  172. #pragma segment SearchSpec
  173.  
  174. //----------------------------------------------------------------------------------------
  175. // TLogicalSearchSpec::~TLogicalSearchSpec: 
  176. //----------------------------------------------------------------------------------------
  177. TLogicalSearchSpec::~TLogicalSearchSpec()
  178.     {
  179.     delete fListOfLogicalTerms;
  180.     } // TLogicalSearchSpec::~TLogicalSearchSpec 
  181.  
  182. //----------------------------------------------------------------------------------------
  183. // TLogicalSearchSpec::SpecificationOperator: 
  184. //----------------------------------------------------------------------------------------
  185. DescType TLogicalSearchSpec::SpecificationOperator()
  186.     {
  187.     return fLogicalOperator;
  188.     } // TLogicalSearchSpec::SpecificationOperator 
  189.  
  190. //----------------------------------------------------------------------------------------
  191. // TLogicalSearchSpec::NumberOfSubterms
  192. //----------------------------------------------------------------------------------------
  193. long TLogicalSearchSpec::NumberOfSubterms()
  194.     {
  195.     return fListOfLogicalTerms->ItemsInList();
  196.     }
  197.     
  198. //----------------------------------------------------------------------------------------
  199. // TLogicalSearchSpec::SpecificationForTerm
  200. //----------------------------------------------------------------------------------------
  201. TAbstractSearchSpec* TLogicalSearchSpec::SpecificationForTerm(long term)
  202.     {
  203.     return (TAbstractSearchSpec*) fListOfLogicalTerms->ItemAtIndex(term);
  204.     }
  205.  
  206. //----------------------------------------------------------------------------------------
  207. // TLogicalSearchSpec::Compare: 
  208. //----------------------------------------------------------------------------------------
  209. Boolean TLogicalSearchSpec::Compare(const TAETransaction& t, TAbstractScriptableObject* itemToTest)
  210.     {
  211.     //
  212.     // If the logical operator is not kAEOR, then kAEAND is
  213.     // assumed (thus, kAENOT is really kAENAND).
  214.     //
  215.     Boolean result = this->SpecificationOperator() == kAEOR ? false : true;
  216.     
  217.     //
  218.     // Compare each of the subspecifications of this logical spec
  219.     //
  220.     for(AnIteratorOfAListOf<TAbstractSearchSpec*> iter(fListOfLogicalTerms); iter.More(); iter.Next())
  221.         {
  222.         Boolean intermediate = iter.Current()->Compare(t, itemToTest);
  223.         
  224.         //
  225.         // Once again, we treat kAEOR specially, and all other
  226.         // operations (kAEAND and kAENOT) are treated as AND
  227.         //
  228.         if(this->SpecificationOperator() == kAEOR)
  229.             {
  230.             result |= intermediate;
  231.             if(result)
  232.                 break;
  233.             }
  234.         else
  235.             {
  236.             result &= intermediate;
  237.             if(!result)
  238.                 break;
  239.             }
  240.         }
  241.     
  242.     //
  243.     // Negate the result if the logical operator is kAENOT.
  244.     //
  245.     if(this->SpecificationOperator() == kAENOT)
  246.         result = !result;
  247.     
  248.     return result;
  249.     } // TLogicalSearchSpec::Compare 
  250.  
  251. //----------------------------------------------------------------------------------------
  252. // TLogicalSearchSpec::BuildWhoseTest: 
  253. //----------------------------------------------------------------------------------------
  254. TDescriptor TLogicalSearchSpec::BuildWhoseTest()
  255.     {
  256.     TDescriptor specifierOfTerms;
  257.     TDescriptor listOfTerms;
  258.     TDescriptor oneTerm;
  259.     TDescriptor logicalOperator;
  260.     
  261.     //
  262.     // Create an AE record
  263.     //
  264.     specifierOfTerms.MakeAERecord();
  265.     
  266.     //
  267.     // Make a logical operator to go inside the record
  268.     //
  269.     logicalOperator.SetDescTypeData(this->SpecificationOperator(), typeEnumeration);
  270.     specifierOfTerms.PutDescriptorParameter(keyAELogicalOperator, logicalOperator);
  271.     logicalOperator.Dispose();
  272.     
  273.     //
  274.     // Build a list of specifiers for all of the terms
  275.     // in this search specification
  276.     //
  277.     for(AnIteratorOfAListOf<TAbstractSearchSpec*> iter(fListOfLogicalTerms); iter.More(); iter.Next())
  278.         {
  279.         oneTerm = iter.Current()->BuildWhoseTest();
  280.         listOfTerms.AddItemToList(oneTerm);
  281.         oneTerm.Dispose();
  282.         }
  283.     specifierOfTerms.PutDescriptorParameter(keyAELogicalTerms, listOfTerms);
  284.     listOfTerms.Dispose();
  285.     
  286.     return specifierOfTerms;
  287.     } // TLogicalSearchSpec::BuildWhoseTest 
  288.  
  289. //----------------------------------------------------------------------------------------
  290. // TLogicalSearchSpec::AddTermToSpecification
  291. //----------------------------------------------------------------------------------------
  292. TAbstractSearchSpec* TLogicalSearchSpec::AddTermToSpecification(TAbstractSearchSpec* newSpecification)
  293.     {
  294.     fListOfLogicalTerms->Add(newSpecification);
  295.     
  296.     return this;
  297.     } // TLogicalSearchSpec::AddTermToSpecification
  298.